struct int4
{
	int x;
	int y;
	int z;
	int w;

	int4(const int _x, const int _y, const int _z, const int _w) :
		x(_x),
		y(_y),
		z(_z),
		w(_w)
	{
	}

	int4(const int f) :
		x(f),
		y(f),
		z(f),
		w(f)
	{
	}

	int4() :
		x(0),
		y(0),
		z(0),
		w(0)
	{ }

	const int4& operator=(const int& other)
	{
		x = other;
		y = other;
		z = other;
		w = other;

		return *this;
	}

	const int4& operator=(const int4& other)
	{
		x = other.x;
		y = other.y;
		z = other.z;
		w = other.w;

		return *this;
	}

	int4 operator*(const int4& other) const
	{
		int4 ret;
		ret.x = x*other.x;
		ret.y = y*other.y;
		ret.z = z*other.z;
		ret.w = w*other.w;
		return ret;
	}

	int4 operator*(const int& other) const
	{
		int4 ret;
		ret.x = x*other;
		ret.y = y*other;
		ret.z = z*other;
		ret.w = w*other;
		return ret;
	}

	int4 operator/(const int& other) const
	{
		int4 ret;
		ret.x = x/other;
		ret.y = y/other;
		ret.z = z/other;
		ret.w = w/other;
		return ret;
	}

	int4 operator+(const int4& other) const
	{
		int4 ret;
		ret.x = x+other.x;
		ret.y = y+other.y;
		ret.z = z+other.z;
		ret.w = w+other.w;
		return ret;
	}

	int4 operator+(const int& other) const
	{
		int4 ret;
		ret.x = x+other;
		ret.y = y+other;
		ret.z = z+other;
		ret.w = w+other;
		return ret;
	}

	int4 operator-(const int4& other) const
	{
		int4 ret;
		ret.x = x-other.x;
		ret.y = y-other.y;
		ret.z = z-other.z;
		ret.w = w-other.w;
		return ret;
	}
};

struct int3
{
	int x;
	int y;
	int z;

	int3(const int& f) :
		x(f),
		y(f),
		z(f)
	{
	}

	int3(const int& _x, const int& _y, const int& _z) :
		x(_x),
		y(_y),
		z(_z)
	{
	}

	int3() :
		x(0),
		y(0),
		z(0)
	{ }

	const int3& operator=(const int& other)
	{
		x = other;
		y = other;
		z = other;

		return *this;
	}

	const int3& operator=(const int3& other)
	{
		x = other.x;
		y = other.y;
		z = other.z;

		return *this;
	}

	int3 operator*(const int3& other) const
	{
		int3 ret;
		ret.x = x*other.x;
		ret.z = y*other.y;
		ret.y = z*other.z;
		return ret;
	}

	int3 operator*(const int& other) const
	{
		int3 ret;
		ret.x = x*other;
		ret.y = y*other;
		ret.z = z*other;
		return ret;
	}

	int3 operator/(const int& other) const
	{
		int3 ret;
		ret.x = x/other;
		ret.y = y/other;
		ret.z = z/other;
		return ret;
	}

	int3 operator+(const int3& other) const
	{
		int3 ret;
		ret.x = x+other.x;
		ret.y = y+other.y;
		ret.z = z+other.z;
		return ret;
	}

	int3 operator+(const int& other) const
	{
		int3 ret;
		ret.x = x+other;
		ret.y = y+other;
		ret.z = z+other;
		return ret;
	}

	int3 operator-(const int3& other) const
	{
		int3 ret;
		ret.x = x-other.x;
		ret.y = y-other.y;
		ret.z = z-other.z;
		return ret;
	}
};

struct int2
{
	int x;
	int y;

	int2() :
		x(0),
		y(0)
	{ }

	int2(const int _x, const int _y) :
		x(_x),
		y(_y)
	{
	}

	int2(const int f) :
		x(f),
		y(f)
	{
	}

	const int2& operator=(const int& other)
	{
		x = other;
		y = other;

		return *this;
	}

	int2 operator*(const int2& other) const
	{
		int2 ret;
		ret.x = x*other.x;
		ret.y = y*other.y;
		return ret;
	}

	int2 operator*(const int& other) const
	{
		int2 ret;
		ret.x = x*other;
		ret.y = y*other;
		return ret;
	}

	int2 operator/(const int& other) const
	{
		int2 ret;
		ret.x = x/other;
		ret.y = y/other;
		return ret;
	}

	int2 operator+(const int2& other) const
	{
		int2 ret;
		ret.x = x+other.x;
		ret.y = y+other.y;
		return ret;
	}

	int2 operator+(const int& other) const
	{
		int2 ret;
		ret.x = x+other;
		ret.y = y+other;
		return ret;
	}

	int2 operator-(const int2& other) const
	{
		int2 ret;
		ret.x = x-other.x;
		ret.y = y-other.y;
		return ret;
	}
};